package com.yinxianren.main.mybatis_plus;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yinxianren.main.study.mybatis_plus.dao.UserMapper;
import com.yinxianren.main.study.mybatis_plus.entity.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.*;

@RunWith(SpringRunner.class)
@SpringBootTest
public class CRUD_R {

    @Autowired
    private UserMapper userMapper;

    /**
     * <p>
     * 根据 ID 查询
     * </p>
     *
     * @param id 主键ID
     * @return 实体
     *
     *  T selectById(Serializable id);
     */
    @Test
    public void selectById(){
        User user=userMapper.selectById(1);
        System.out.println(user.toString());
    }


    /**
     * <p>
     * 查询（根据ID 批量查询）
     * </p>
     *
     * @param idList 主键ID列表(不能为 null 以及 empty)
     * @return 实体集合
     *
     *   List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
     */
    @Test
    public void selectBachIds(){
        List<Integer> list=new ArrayList<>();
        Integer[]  ids=new Integer[]{1,2,5};
        list.addAll(Arrays.asList(ids));
        List<User> userList=userMapper.selectBatchIds(list);
        userList.forEach(System.out::println);
    }


    /**
     * <p>
     * 查询（根据 columnMap 条件）
     * </p>
     *
     * @param columnMap 表字段 map 对象
     * @return 实体集合
     *
     *     List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
     */

    @Test
    public void selectByMap(){
        Map<String,Object> map=new HashMap<>();
        map.put("age",18);
        List<User> userList= userMapper.selectByMap(map);
        userList.forEach(System.out::println);
    }


    /**
     * <p>
     * 根据 entity 条件，查询一条记录
     * </p>
     *
     * @param queryWrapper 实体对象
     * @return 实体
     *
     * T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
     */

    @Test
    public void selectOne(){
        QueryWrapper<User> qw=new QueryWrapper<>();
//        qw.between("age",18,25);
        qw.eq("name","Jack");
        User user= userMapper.selectOne(qw);
        System.out.println(user.toString());
    }

    /**
     * <p>
     * 根据 Wrapper 条件，查询总记录数
     * </p>
     *
     * @param queryWrapper 实体对象
     * @return 满足条件记录数
     * Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
     */

    @Test
    public void selectCount(){
        QueryWrapper<User> qw=new QueryWrapper<>();
        qw.ge(true,"age",18);
        int count=userMapper.selectCount(qw);
        System.out.println(count);
    }


    /**
     * <p>
     * 根据 entity 条件，查询全部记录
     * </p>
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     * @return 实体集合
     *   List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
     */

    @Test
    public  void selectList(){
        QueryWrapper<User> qw=new QueryWrapper<>();
        //普通写法
//        String[] column=new String[]{"id","name","age"};
//        qw.select(column);
        qw.ge("age",18);
        List<User>  userList=userMapper.selectList(qw);
        userList.forEach(System.out::println);
        System.out.println("----------------------------------------");
        //lambda表达式写法
//        LambdaQueryWrapper<User> lqw=qw.lambda();
//        lqw.select();

    }

    /**
     * <p>
     * 根据 Wrapper 条件，查询全部记录
     * </p>
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     * @return 字段映射对象 Map 集合
     *
     *   List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
     *
     *  Jone
     * 1
     * 18
     * test1@baomidou.com
     * Jack
     * 2
     * 20
     * test2@baomidou.com
     * Tom
     * 3
     * 28
     * test3@baomidou.com
     * Sandy
     * 4
     * 21
     * test4@baomidou.com
     * Billie
     * 5
     * 24
     * test5@baomidou.com
     */
    @Test
    public void selectMaps(){
        QueryWrapper<User>  qw=new QueryWrapper<>();
        qw.ge("age",18);
        List<Map<String, Object>> mapList =userMapper.selectMaps(qw);
        mapList.forEach(map->{
            for(String key:map.keySet()){
                //key->name   value->Tom
                Object obj=  map.get(key);
                System.out.println(obj.toString());
            }
        });
    }



    /**
     * <p>
     * 根据 Wrapper 条件，查询全部记录
     * 注意： 只返回第一个字段的值
     * </p>
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     * @return 字段映射对象集合
     *   List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
     */

    @Test
    public void selectObjs(){
        QueryWrapper<User>  qw=new QueryWrapper<>();
        qw.ge("age",18);
        List<Object> userList=userMapper.selectObjs(qw);
        userList.forEach(System.out::println);
    }


    /**
     * <p>
     * 根据 entity 条件，查询全部记录（并翻页）
     * </p>
     *
     * @param page         分页查询条件（可以为 RowBounds.DEFAULT）
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     * @return 实体分页对象
     *   IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
     */
    @Test
    public void selectPage(){
        QueryWrapper<User>  qw=new QueryWrapper<>();
        qw.ge("age",18);
        int count=userMapper.selectCount(qw);
//public Page(long current, long size, long total, boolean isSearchCount)
        Page<User> page=new Page(1,3,count);
//        page.setTotal(count);
//        page.setCurrent(1);
//        page.setSize(3);
        page.setDesc("age");
       IPage<User>  userIPage=userMapper.selectPage(page,qw);
       List userList=userIPage.getRecords();
       userList.forEach(System.out::println);
    }


    /**
     * <p>
     * 根据 Wrapper 条件，查询全部记录（并翻页）
     * </p>
     *
     * @param page         分页查询条件
     * @param queryWrapper 实体对象封装操作类
     * @return 字段映射对象 Map 分页对象
     *  IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
     */

    public void selectMapsPage(){
        QueryWrapper<User>  qw=new QueryWrapper<>();
        qw.ge("age",24);
        Page<User> page=new Page();
        IPage<Map<String, Object>> mapIPage= userMapper.selectMapsPage(page,qw);
    }
}
